home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the 3D Game Programming Gurus / gurus.iso / DirectX / dx9sdkcp.exe / SDK (C++) / Include / d3dx9math.inl < prev    next >
Encoding:
Text File  |  2002-11-12  |  42.8 KB  |  2,166 lines
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  Copyright (C) Microsoft Corporation.  All Rights Reserved.
  4. //
  5. //  File:       d3dx9math.inl
  6. //  Content:    D3DX math inline functions
  7. //
  8. //////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifndef __D3DX9MATH_INL__
  11. #define __D3DX9MATH_INL__
  12.  
  13.  
  14. //===========================================================================
  15. //
  16. // Inline Class Methods
  17. //
  18. //===========================================================================
  19.  
  20. #ifdef __cplusplus
  21.  
  22. //--------------------------
  23. // Float16
  24. //--------------------------
  25.  
  26. D3DXINLINE
  27. D3DXFLOAT16::D3DXFLOAT16( FLOAT f )
  28. {
  29.     D3DXFloat32To16Array(this, &f, 1);
  30. }
  31.  
  32. D3DXINLINE
  33. D3DXFLOAT16::D3DXFLOAT16( CONST D3DXFLOAT16& f )
  34. {
  35.     value = f.value;
  36. }
  37.  
  38. // casting
  39. D3DXINLINE
  40. D3DXFLOAT16::operator FLOAT ()
  41. {
  42.     FLOAT f;
  43.     D3DXFloat16To32Array(&f, this, 1);
  44.     return f;
  45. }
  46.  
  47. // binary operators
  48. D3DXINLINE BOOL
  49. D3DXFLOAT16::operator == ( CONST D3DXFLOAT16& f ) const
  50. {
  51.     return value == f.value;
  52. }
  53.  
  54. D3DXINLINE BOOL
  55. D3DXFLOAT16::operator != ( CONST D3DXFLOAT16& f ) const
  56. {
  57.     return value != f.value;
  58. }
  59.  
  60.  
  61. //--------------------------
  62. // 2D Vector
  63. //--------------------------
  64.  
  65. D3DXINLINE
  66. D3DXVECTOR2::D3DXVECTOR2( CONST FLOAT *pf )
  67. {
  68. #ifdef D3DX_DEBUG
  69.     if(!pf)
  70.         return;
  71. #endif
  72.  
  73.     x = pf[0];
  74.     y = pf[1];
  75. }
  76.  
  77. D3DXINLINE
  78. D3DXVECTOR2::D3DXVECTOR2( CONST D3DXFLOAT16 *pf )
  79. {
  80. #ifdef D3DX_DEBUG
  81.     if(!pf)
  82.         return;
  83. #endif
  84.  
  85.     D3DXFloat16To32Array(&x, pf, 2);    
  86. }
  87.  
  88. D3DXINLINE
  89. D3DXVECTOR2::D3DXVECTOR2( FLOAT fx, FLOAT fy )
  90. {
  91. #ifdef D3DX_DEBUG
  92.     if(!pf)
  93.         return;
  94. #endif
  95.  
  96.     x = fx;
  97.     y = fy;
  98. }
  99.  
  100. // casting
  101. D3DXINLINE
  102. D3DXVECTOR2::operator FLOAT* ()
  103. {
  104.     return (FLOAT *) &x;
  105. }
  106.  
  107. D3DXINLINE
  108. D3DXVECTOR2::operator CONST FLOAT* () const
  109. {
  110.     return (CONST FLOAT *) &x;
  111. }
  112.  
  113. // assignment operators
  114. D3DXINLINE D3DXVECTOR2&
  115. D3DXVECTOR2::operator += ( CONST D3DXVECTOR2& v )
  116. {
  117.     x += v.x;
  118.     y += v.y;
  119.     return *this;
  120. }
  121.  
  122. D3DXINLINE D3DXVECTOR2&
  123. D3DXVECTOR2::operator -= ( CONST D3DXVECTOR2& v )
  124. {
  125.     x -= v.x;
  126.     y -= v.y;
  127.     return *this;
  128. }
  129.  
  130. D3DXINLINE D3DXVECTOR2&
  131. D3DXVECTOR2::operator *= ( FLOAT f )
  132. {
  133.     x *= f;
  134.     y *= f;
  135.     return *this;
  136. }
  137.  
  138. D3DXINLINE D3DXVECTOR2&
  139. D3DXVECTOR2::operator /= ( FLOAT f )
  140. {
  141.     FLOAT fInv = 1.0f / f;
  142.     x *= fInv;
  143.     y *= fInv;
  144.     return *this;
  145. }
  146.  
  147. // unary operators
  148. D3DXINLINE D3DXVECTOR2
  149. D3DXVECTOR2::operator + () const
  150. {
  151.     return *this;
  152. }
  153.  
  154. D3DXINLINE D3DXVECTOR2
  155. D3DXVECTOR2::operator - () const
  156. {
  157.     return D3DXVECTOR2(-x, -y);
  158. }
  159.  
  160. // binary operators
  161. D3DXINLINE D3DXVECTOR2
  162. D3DXVECTOR2::operator + ( CONST D3DXVECTOR2& v ) const
  163. {
  164.     return D3DXVECTOR2(x + v.x, y + v.y);
  165. }
  166.  
  167. D3DXINLINE D3DXVECTOR2
  168. D3DXVECTOR2::operator - ( CONST D3DXVECTOR2& v ) const
  169. {
  170.     return D3DXVECTOR2(x - v.x, y - v.y);
  171. }
  172.  
  173. D3DXINLINE D3DXVECTOR2
  174. D3DXVECTOR2::operator * ( FLOAT f ) const
  175. {
  176.     return D3DXVECTOR2(x * f, y * f);
  177. }
  178.  
  179. D3DXINLINE D3DXVECTOR2
  180. D3DXVECTOR2::operator / ( FLOAT f ) const
  181. {
  182.     FLOAT fInv = 1.0f / f;
  183.     return D3DXVECTOR2(x * fInv, y * fInv);
  184. }
  185.  
  186.  
  187. D3DXINLINE D3DXVECTOR2
  188. operator * ( FLOAT f, CONST D3DXVECTOR2& v )
  189. {
  190.     return D3DXVECTOR2(f * v.x, f * v.y);
  191. }
  192.  
  193. D3DXINLINE BOOL
  194. D3DXVECTOR2::operator == ( CONST D3DXVECTOR2& v ) const
  195. {
  196.     return x == v.x && y == v.y;
  197. }
  198.  
  199. D3DXINLINE BOOL
  200. D3DXVECTOR2::operator != ( CONST D3DXVECTOR2& v ) const
  201. {
  202.     return x != v.x || y != v.y;
  203. }
  204.  
  205.  
  206.  
  207. //--------------------------
  208. // 2D Vector (16 bit)
  209. //--------------------------
  210.  
  211. D3DXINLINE
  212. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST FLOAT *pf )
  213. {
  214. #ifdef D3DX_DEBUG
  215.     if(!pf)
  216.         return;
  217. #endif
  218.  
  219.     D3DXFloat32To16Array(&x, pf, 2);
  220. }
  221.  
  222. D3DXINLINE
  223. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 *pf )
  224. {
  225. #ifdef D3DX_DEBUG
  226.     if(!pf)
  227.         return;
  228. #endif
  229.  
  230.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  231. }
  232.  
  233. D3DXINLINE
  234. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy )
  235. {
  236.     x = fx;
  237.     y = fy;
  238. }
  239.  
  240. // casting
  241. D3DXINLINE
  242. D3DXVECTOR2_16F::operator D3DXFLOAT16* ()
  243. {
  244.     return (D3DXFLOAT16*) &x;
  245. }
  246.  
  247. D3DXINLINE
  248. D3DXVECTOR2_16F::operator CONST D3DXFLOAT16* () const
  249. {
  250.     return (CONST D3DXFLOAT16*) &x;
  251. }
  252.  
  253. // binary operators
  254. D3DXINLINE BOOL 
  255. D3DXVECTOR2_16F::operator == ( CONST D3DXVECTOR2_16F &v ) const
  256. {
  257.     return *((DWORD *) &x) == *((DWORD *) &v.x);
  258. }
  259.  
  260. D3DXINLINE BOOL 
  261. D3DXVECTOR2_16F::operator != ( CONST D3DXVECTOR2_16F &v ) const
  262. {
  263.     return *((DWORD *) &x) != *((DWORD *) &v.x);
  264. }
  265.  
  266.  
  267. //--------------------------
  268. // 3D Vector
  269. //--------------------------
  270. D3DXINLINE
  271. D3DXVECTOR3::D3DXVECTOR3( CONST FLOAT *pf )
  272. {
  273. #ifdef D3DX_DEBUG
  274.     if(!pf)
  275.         return;
  276. #endif
  277.  
  278.     x = pf[0];
  279.     y = pf[1];
  280.     z = pf[2];
  281. }
  282.  
  283. D3DXINLINE
  284. D3DXVECTOR3::D3DXVECTOR3( CONST D3DVECTOR& v )
  285. {
  286.     x = v.x;
  287.     y = v.y;
  288.     z = v.z;
  289. }
  290.  
  291. D3DXINLINE
  292. D3DXVECTOR3::D3DXVECTOR3( CONST D3DXFLOAT16 *pf )
  293. {
  294. #ifdef D3DX_DEBUG
  295.     if(!pf)
  296.         return;
  297. #endif
  298.  
  299.     D3DXFloat16To32Array(&x, pf, 3);
  300. }
  301.  
  302. D3DXINLINE
  303. D3DXVECTOR3::D3DXVECTOR3( FLOAT fx, FLOAT fy, FLOAT fz )
  304. {
  305.     x = fx;
  306.     y = fy;
  307.     z = fz;
  308. }
  309.  
  310.  
  311. // casting
  312. D3DXINLINE
  313. D3DXVECTOR3::operator FLOAT* ()
  314. {
  315.     return (FLOAT *) &x;
  316. }
  317.  
  318. D3DXINLINE
  319. D3DXVECTOR3::operator CONST FLOAT* () const
  320. {
  321.     return (CONST FLOAT *) &x;
  322. }
  323.  
  324.  
  325. // assignment operators
  326. D3DXINLINE D3DXVECTOR3&
  327. D3DXVECTOR3::operator += ( CONST D3DXVECTOR3& v )
  328. {
  329.     x += v.x;
  330.     y += v.y;
  331.     z += v.z;
  332.     return *this;
  333. }
  334.  
  335. D3DXINLINE D3DXVECTOR3&
  336. D3DXVECTOR3::operator -= ( CONST D3DXVECTOR3& v )
  337. {
  338.     x -= v.x;
  339.     y -= v.y;
  340.     z -= v.z;
  341.     return *this;
  342. }
  343.  
  344. D3DXINLINE D3DXVECTOR3&
  345. D3DXVECTOR3::operator *= ( FLOAT f )
  346. {
  347.     x *= f;
  348.     y *= f;
  349.     z *= f;
  350.     return *this;
  351. }
  352.  
  353. D3DXINLINE D3DXVECTOR3&
  354. D3DXVECTOR3::operator /= ( FLOAT f )
  355. {
  356.     FLOAT fInv = 1.0f / f;
  357.     x *= fInv;
  358.     y *= fInv;
  359.     z *= fInv;
  360.     return *this;
  361. }
  362.  
  363.  
  364. // unary operators
  365. D3DXINLINE D3DXVECTOR3
  366. D3DXVECTOR3::operator + () const
  367. {
  368.     return *this;
  369. }
  370.  
  371. D3DXINLINE D3DXVECTOR3
  372. D3DXVECTOR3::operator - () const
  373. {
  374.     return D3DXVECTOR3(-x, -y, -z);
  375. }
  376.  
  377.  
  378. // binary operators
  379. D3DXINLINE D3DXVECTOR3
  380. D3DXVECTOR3::operator + ( CONST D3DXVECTOR3& v ) const
  381. {
  382.     return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
  383. }
  384.  
  385. D3DXINLINE D3DXVECTOR3
  386. D3DXVECTOR3::operator - ( CONST D3DXVECTOR3& v ) const
  387. {
  388.     return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
  389. }
  390.  
  391. D3DXINLINE D3DXVECTOR3
  392. D3DXVECTOR3::operator * ( FLOAT f ) const
  393. {
  394.     return D3DXVECTOR3(x * f, y * f, z * f);
  395. }
  396.  
  397. D3DXINLINE D3DXVECTOR3
  398. D3DXVECTOR3::operator / ( FLOAT f ) const
  399. {
  400.     FLOAT fInv = 1.0f / f;
  401.     return D3DXVECTOR3(x * fInv, y * fInv, z * fInv);
  402. }
  403.  
  404.  
  405. D3DXINLINE D3DXVECTOR3
  406. operator * ( FLOAT f, CONST struct D3DXVECTOR3& v )
  407. {
  408.     return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
  409. }
  410.  
  411.  
  412. D3DXINLINE BOOL
  413. D3DXVECTOR3::operator == ( CONST D3DXVECTOR3& v ) const
  414. {
  415.     return x == v.x && y == v.y && z == v.z;
  416. }
  417.  
  418. D3DXINLINE BOOL
  419. D3DXVECTOR3::operator != ( CONST D3DXVECTOR3& v ) const
  420. {
  421.     return x != v.x || y != v.y || z != v.z;
  422. }
  423.  
  424.  
  425.  
  426. //--------------------------
  427. // 3D Vector (16 bit)
  428. //--------------------------
  429.  
  430. D3DXINLINE
  431. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST FLOAT *pf )
  432. {
  433. #ifdef D3DX_DEBUG
  434.     if(!pf)
  435.         return;
  436. #endif
  437.  
  438.     D3DXFloat32To16Array(&x, pf, 3);
  439. }
  440.  
  441. D3DXINLINE
  442. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DVECTOR& v )
  443. {
  444.     D3DXFloat32To16Array(&x, &v.x, 1);
  445.     D3DXFloat32To16Array(&y, &v.y, 1);
  446.     D3DXFloat32To16Array(&z, &v.z, 1);
  447. }
  448.  
  449. D3DXINLINE
  450. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 *pf )
  451. {
  452. #ifdef D3DX_DEBUG
  453.     if(!pf)
  454.         return;
  455. #endif
  456.  
  457.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  458.     *((WORD  *) &z) = *((WORD  *) &pf[2]);
  459. }
  460.  
  461. D3DXINLINE
  462. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz )
  463. {
  464.     x = fx;
  465.     y = fy;
  466.     z = fz;
  467. }
  468.  
  469. // casting
  470. D3DXINLINE
  471. D3DXVECTOR3_16F::operator D3DXFLOAT16* ()
  472. {
  473.     return (D3DXFLOAT16*) &x;
  474. }
  475.  
  476. D3DXINLINE
  477. D3DXVECTOR3_16F::operator CONST D3DXFLOAT16* () const
  478. {
  479.     return (CONST D3DXFLOAT16*) &x;
  480. }
  481.  
  482. // binary operators
  483. D3DXINLINE BOOL 
  484. D3DXVECTOR3_16F::operator == ( CONST D3DXVECTOR3_16F &v ) const
  485. {
  486.     return *((DWORD *) &x) == *((DWORD *) &v.x) &&
  487.            *((WORD  *) &z) == *((WORD  *) &v.z);
  488. }
  489.  
  490. D3DXINLINE BOOL 
  491. D3DXVECTOR3_16F::operator != ( CONST D3DXVECTOR3_16F &v ) const
  492. {
  493.     return *((DWORD *) &x) != *((DWORD *) &v.x) ||
  494.            *((WORD  *) &z) != *((WORD  *) &v.z);
  495. }
  496.  
  497.  
  498.  
  499. //--------------------------
  500. // 4D Vector
  501. //--------------------------
  502. D3DXINLINE
  503. D3DXVECTOR4::D3DXVECTOR4( CONST FLOAT *pf )
  504. {
  505. #ifdef D3DX_DEBUG
  506.     if(!pf)
  507.         return;
  508. #endif
  509.  
  510.     x = pf[0];
  511.     y = pf[1];
  512.     z = pf[2];
  513.     w = pf[3];
  514. }
  515.  
  516. D3DXINLINE
  517. D3DXVECTOR4::D3DXVECTOR4( CONST D3DXFLOAT16 *pf )
  518. {
  519. #ifdef D3DX_DEBUG
  520.     if(!pf)
  521.         return;
  522. #endif
  523.  
  524.     D3DXFloat16To32Array(&x, pf, 4);
  525. }
  526.  
  527. D3DXINLINE
  528. D3DXVECTOR4::D3DXVECTOR4( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
  529. {
  530.     x = fx;
  531.     y = fy;
  532.     z = fz;
  533.     w = fw;
  534. }
  535.  
  536. // casting
  537. D3DXINLINE
  538. D3DXVECTOR4::operator FLOAT* ()
  539. {
  540.     return (FLOAT *) &x;
  541. }
  542.  
  543. D3DXINLINE
  544. D3DXVECTOR4::operator CONST FLOAT* () const
  545. {
  546.     return (CONST FLOAT *) &x;
  547. }
  548.  
  549.  
  550. // assignment operators
  551. D3DXINLINE D3DXVECTOR4&
  552. D3DXVECTOR4::operator += ( CONST D3DXVECTOR4& v )
  553. {
  554.     x += v.x;
  555.     y += v.y;
  556.     z += v.z;
  557.     w += v.w;
  558.     return *this;
  559. }
  560.  
  561. D3DXINLINE D3DXVECTOR4&
  562. D3DXVECTOR4::operator -= ( CONST D3DXVECTOR4& v )
  563. {
  564.     x -= v.x;
  565.     y -= v.y;
  566.     z -= v.z;
  567.     w -= v.w;
  568.     return *this;
  569. }
  570.  
  571. D3DXINLINE D3DXVECTOR4&
  572. D3DXVECTOR4::operator *= ( FLOAT f )
  573. {
  574.     x *= f;
  575.     y *= f;
  576.     z *= f;
  577.     w *= f;
  578.     return *this;
  579. }
  580.  
  581. D3DXINLINE D3DXVECTOR4&
  582. D3DXVECTOR4::operator /= ( FLOAT f )
  583. {
  584.     FLOAT fInv = 1.0f / f;
  585.     x *= fInv;
  586.     y *= fInv;
  587.     z *= fInv;
  588.     w *= fInv;
  589.     return *this;
  590. }
  591.  
  592.  
  593. // unary operators
  594. D3DXINLINE D3DXVECTOR4
  595. D3DXVECTOR4::operator + () const
  596. {
  597.     return *this;
  598. }
  599.  
  600. D3DXINLINE D3DXVECTOR4
  601. D3DXVECTOR4::operator - () const
  602. {
  603.     return D3DXVECTOR4(-x, -y, -z, -w);
  604. }
  605.  
  606.  
  607. // binary operators
  608. D3DXINLINE D3DXVECTOR4
  609. D3DXVECTOR4::operator + ( CONST D3DXVECTOR4& v ) const
  610. {
  611.     return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
  612. }
  613.  
  614. D3DXINLINE D3DXVECTOR4
  615. D3DXVECTOR4::operator - ( CONST D3DXVECTOR4& v ) const
  616. {
  617.     return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
  618. }
  619.  
  620. D3DXINLINE D3DXVECTOR4
  621. D3DXVECTOR4::operator * ( FLOAT f ) const
  622. {
  623.     return D3DXVECTOR4(x * f, y * f, z * f, w * f);
  624. }
  625.  
  626. D3DXINLINE D3DXVECTOR4
  627. D3DXVECTOR4::operator / ( FLOAT f ) const
  628. {
  629.     FLOAT fInv = 1.0f / f;
  630.     return D3DXVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv);
  631. }
  632.  
  633.  
  634. D3DXINLINE D3DXVECTOR4
  635. operator * ( FLOAT f, CONST D3DXVECTOR4& v )
  636. {
  637.     return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
  638. }
  639.  
  640.  
  641. D3DXINLINE BOOL
  642. D3DXVECTOR4::operator == ( CONST D3DXVECTOR4& v ) const
  643. {
  644.     return x == v.x && y == v.y && z == v.z && w == v.w;
  645. }
  646.  
  647. D3DXINLINE BOOL
  648. D3DXVECTOR4::operator != ( CONST D3DXVECTOR4& v ) const
  649. {
  650.     return x != v.x || y != v.y || z != v.z || w != v.w;
  651. }
  652.  
  653.  
  654.  
  655. //--------------------------
  656. // 4D Vector (16 bit)
  657. //--------------------------
  658.  
  659. D3DXINLINE
  660. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST FLOAT *pf )
  661. {
  662. #ifdef D3DX_DEBUG
  663.     if(!pf)
  664.         return;
  665. #endif
  666.  
  667.     D3DXFloat32To16Array(&x, pf, 4);
  668. }
  669.  
  670. D3DXINLINE
  671. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 *pf )
  672. {
  673. #ifdef D3DX_DEBUG
  674.     if(!pf)
  675.         return;
  676. #endif
  677.  
  678.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  679.     *((DWORD *) &z) = *((DWORD *) &pf[2]);
  680. }
  681.  
  682. D3DXINLINE
  683. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz, CONST D3DXFLOAT16 &fw )
  684. {
  685.     x = fx;
  686.     y = fy;
  687.     z = fz;
  688.     w = fw;
  689. }
  690.  
  691. // casting
  692. D3DXINLINE
  693. D3DXVECTOR4_16F::operator D3DXFLOAT16* ()
  694. {
  695.     return (D3DXFLOAT16*) &x;
  696. }
  697.  
  698. D3DXINLINE
  699. D3DXVECTOR4_16F::operator CONST D3DXFLOAT16* () const
  700. {
  701.     return (CONST D3DXFLOAT16*) &x;
  702. }
  703.  
  704. // binary operators
  705. D3DXINLINE BOOL 
  706. D3DXVECTOR4_16F::operator == ( CONST D3DXVECTOR4_16F &v ) const
  707. {
  708.     return *((DWORD *) &x) == *((DWORD *) &v.x) &&
  709.            *((DWORD *) &z) == *((DWORD *) &v.z);
  710. }
  711.  
  712. D3DXINLINE BOOL 
  713. D3DXVECTOR4_16F::operator != ( CONST D3DXVECTOR4_16F &v ) const
  714. {
  715.     return *((DWORD *) &x) != *((DWORD *) &v.x) ||
  716.            *((DWORD *) &z) != *((DWORD *) &v.z);
  717. }
  718.  
  719.  
  720. //--------------------------
  721. // Matrix
  722. //--------------------------
  723. D3DXINLINE
  724. D3DXMATRIX::D3DXMATRIX( CONST FLOAT* pf )
  725. {
  726. #ifdef D3DX_DEBUG
  727.     if(!pf)
  728.         return;
  729. #endif
  730.  
  731.     memcpy(&_11, pf, sizeof(D3DXMATRIX));
  732. }
  733.  
  734. D3DXINLINE
  735. D3DXMATRIX::D3DXMATRIX( CONST D3DMATRIX& mat )
  736. {
  737.     memcpy(&_11, &mat, sizeof(D3DXMATRIX));
  738. }
  739.  
  740. D3DXINLINE
  741. D3DXMATRIX::D3DXMATRIX( CONST D3DXFLOAT16* pf )
  742. {
  743. #ifdef D3DX_DEBUG
  744.     if(!pf)
  745.         return;
  746. #endif
  747.  
  748.     D3DXFloat16To32Array(&_11, pf, 16);
  749. }
  750.  
  751. D3DXINLINE
  752. D3DXMATRIX::D3DXMATRIX( FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
  753.                         FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
  754.                         FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
  755.                         FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44 )
  756. {
  757.     _11 = f11; _12 = f12; _13 = f13; _14 = f14;
  758.     _21 = f21; _22 = f22; _23 = f23; _24 = f24;
  759.     _31 = f31; _32 = f32; _33 = f33; _34 = f34;
  760.     _41 = f41; _42 = f42; _43 = f43; _44 = f44;
  761. }
  762.  
  763.  
  764.  
  765. // access grants
  766. D3DXINLINE FLOAT&
  767. D3DXMATRIX::operator () ( UINT iRow, UINT iCol )
  768. {
  769.     return m[iRow][iCol];
  770. }
  771.  
  772. D3DXINLINE FLOAT
  773. D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) const
  774. {
  775.     return m[iRow][iCol];
  776. }
  777.  
  778.  
  779. // casting operators
  780. D3DXINLINE
  781. D3DXMATRIX::operator FLOAT* ()
  782. {
  783.     return (FLOAT *) &_11;
  784. }
  785.  
  786. D3DXINLINE
  787. D3DXMATRIX::operator CONST FLOAT* () const
  788. {
  789.     return (CONST FLOAT *) &_11;
  790. }
  791.  
  792.  
  793. // assignment operators
  794. D3DXINLINE D3DXMATRIX&
  795. D3DXMATRIX::operator *= ( CONST D3DXMATRIX& mat )
  796. {
  797.     D3DXMatrixMultiply(this, this, &mat);
  798.     return *this;
  799. }
  800.  
  801. D3DXINLINE D3DXMATRIX&
  802. D3DXMATRIX::operator += ( CONST D3DXMATRIX& mat )
  803. {
  804.     _11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
  805.     _21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
  806.     _31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
  807.     _41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
  808.     return *this;
  809. }
  810.  
  811. D3DXINLINE D3DXMATRIX&
  812. D3DXMATRIX::operator -= ( CONST D3DXMATRIX& mat )
  813. {
  814.     _11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
  815.     _21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
  816.     _31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
  817.     _41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
  818.     return *this;
  819. }
  820.  
  821. D3DXINLINE D3DXMATRIX&
  822. D3DXMATRIX::operator *= ( FLOAT f )
  823. {
  824.     _11 *= f; _12 *= f; _13 *= f; _14 *= f;
  825.     _21 *= f; _22 *= f; _23 *= f; _24 *= f;
  826.     _31 *= f; _32 *= f; _33 *= f; _34 *= f;
  827.     _41 *= f; _42 *= f; _43 *= f; _44 *= f;
  828.     return *this;
  829. }
  830.  
  831. D3DXINLINE D3DXMATRIX&
  832. D3DXMATRIX::operator /= ( FLOAT f )
  833. {
  834.     FLOAT fInv = 1.0f / f;
  835.     _11 *= fInv; _12 *= fInv; _13 *= fInv; _14 *= fInv;
  836.     _21 *= fInv; _22 *= fInv; _23 *= fInv; _24 *= fInv;
  837.     _31 *= fInv; _32 *= fInv; _33 *= fInv; _34 *= fInv;
  838.     _41 *= fInv; _42 *= fInv; _43 *= fInv; _44 *= fInv;
  839.     return *this;
  840. }
  841.  
  842.  
  843. // unary operators
  844. D3DXINLINE D3DXMATRIX
  845. D3DXMATRIX::operator + () const
  846. {
  847.     return *this;
  848. }
  849.  
  850. D3DXINLINE D3DXMATRIX
  851. D3DXMATRIX::operator - () const
  852. {
  853.     return D3DXMATRIX(-_11, -_12, -_13, -_14,
  854.                       -_21, -_22, -_23, -_24,
  855.                       -_31, -_32, -_33, -_34,
  856.                       -_41, -_42, -_43, -_44);
  857. }
  858.  
  859.  
  860. // binary operators
  861. D3DXINLINE D3DXMATRIX
  862. D3DXMATRIX::operator * ( CONST D3DXMATRIX& mat ) const
  863. {
  864.     D3DXMATRIX matT;
  865.     D3DXMatrixMultiply(&matT, this, &mat);
  866.     return matT;
  867. }
  868.  
  869. D3DXINLINE D3DXMATRIX
  870. D3DXMATRIX::operator + ( CONST D3DXMATRIX& mat ) const
  871. {
  872.     return D3DXMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
  873.                       _21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
  874.                       _31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
  875.                       _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
  876. }
  877.  
  878. D3DXINLINE D3DXMATRIX
  879. D3DXMATRIX::operator - ( CONST D3DXMATRIX& mat ) const
  880. {
  881.     return D3DXMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
  882.                       _21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
  883.                       _31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
  884.                       _41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
  885. }
  886.  
  887. D3DXINLINE D3DXMATRIX
  888. D3DXMATRIX::operator * ( FLOAT f ) const
  889. {
  890.     return D3DXMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
  891.                       _21 * f, _22 * f, _23 * f, _24 * f,
  892.                       _31 * f, _32 * f, _33 * f, _34 * f,
  893.                       _41 * f, _42 * f, _43 * f, _44 * f);
  894. }
  895.  
  896. D3DXINLINE D3DXMATRIX
  897. D3DXMATRIX::operator / ( FLOAT f ) const
  898. {
  899.     FLOAT fInv = 1.0f / f;
  900.     return D3DXMATRIX(_11 * fInv, _12 * fInv, _13 * fInv, _14 * fInv,
  901.                       _21 * fInv, _22 * fInv, _23 * fInv, _24 * fInv,
  902.                       _31 * fInv, _32 * fInv, _33 * fInv, _34 * fInv,
  903.                       _41 * fInv, _42 * fInv, _43 * fInv, _44 * fInv);
  904. }
  905.  
  906.  
  907. D3DXINLINE D3DXMATRIX
  908. operator * ( FLOAT f, CONST D3DXMATRIX& mat )
  909. {
  910.     return D3DXMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
  911.                       f * mat._21, f * mat._22, f * mat._23, f * mat._24,
  912.                       f * mat._31, f * mat._32, f * mat._33, f * mat._34,
  913.                       f * mat._41, f * mat._42, f * mat._43, f * mat._44);
  914. }
  915.  
  916.  
  917. D3DXINLINE BOOL
  918. D3DXMATRIX::operator == ( CONST D3DXMATRIX& mat ) const
  919. {
  920.     return 0 == memcmp(this, &mat, sizeof(D3DXMATRIX));
  921. }
  922.  
  923. D3DXINLINE BOOL
  924. D3DXMATRIX::operator != ( CONST D3DXMATRIX& mat ) const
  925. {
  926.     return 0 != memcmp(this, &mat, sizeof(D3DXMATRIX));
  927. }
  928.  
  929.  
  930.  
  931. //--------------------------
  932. // Aligned Matrices
  933. //--------------------------
  934.  
  935. D3DXINLINE
  936. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST FLOAT* f ) : 
  937.     D3DXMATRIX( f ) 
  938. {
  939. }
  940.  
  941. D3DXINLINE
  942. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DMATRIX& m ) : 
  943.     D3DXMATRIX( m ) 
  944. {
  945. }
  946.  
  947. D3DXINLINE
  948. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DXFLOAT16* f ) : 
  949.     D3DXMATRIX( f ) 
  950. {
  951. }
  952.  
  953. D3DXINLINE
  954. _D3DXMATRIXA16::_D3DXMATRIXA16( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,
  955.                                 FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,
  956.                                 FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,
  957.                                 FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ) :
  958.     D3DXMATRIX(_11, _12, _13, _14,
  959.                _21, _22, _23, _24,
  960.                _31, _32, _33, _34,
  961.                _41, _42, _43, _44) 
  962. {
  963. }
  964.  
  965. D3DXINLINE void* 
  966. _D3DXMATRIXA16::operator new( size_t s )
  967. {
  968.     LPBYTE p = ::new BYTE[s + 16];
  969.     if (p)
  970.     {
  971.         BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
  972.         p += offset;
  973.         p[-1] = offset;
  974.     }
  975.     return p;
  976. }
  977.  
  978. D3DXINLINE void* 
  979. _D3DXMATRIXA16::operator new[](size_t s)
  980. {
  981.     LPBYTE p = ::new BYTE[s + 16];
  982.     if (p)
  983.     {
  984.         BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
  985.         p += offset;
  986.         p[-1] = offset;
  987.     }
  988.     return p;
  989. }
  990.  
  991. D3DXINLINE void 
  992. _D3DXMATRIXA16::operator delete(void* p)
  993. {
  994.     if(p)
  995.     {
  996.         BYTE* pb = static_cast<BYTE*>(p);
  997.         pb -= pb[-1];
  998.         ::delete [] pb;
  999.     }
  1000. }
  1001.  
  1002. D3DXINLINE void 
  1003. _D3DXMATRIXA16::operator delete[](void* p)
  1004. {
  1005.     if(p)
  1006.     {
  1007.         BYTE* pb = static_cast<BYTE*>(p);
  1008.         pb -= pb[-1];
  1009.         ::delete [] pb;
  1010.     }
  1011. }
  1012.  
  1013. D3DXINLINE _D3DXMATRIXA16& 
  1014. _D3DXMATRIXA16::operator=(CONST D3DXMATRIX& rhs)
  1015. {
  1016.     memcpy(&_11, &rhs, sizeof(D3DXMATRIX));
  1017.     return *this;
  1018. }
  1019.  
  1020.  
  1021. //--------------------------
  1022. // Quaternion
  1023. //--------------------------
  1024.  
  1025. D3DXINLINE
  1026. D3DXQUATERNION::D3DXQUATERNION( CONST FLOAT* pf )
  1027. {
  1028. #ifdef D3DX_DEBUG
  1029.     if(!pf)
  1030.         return;
  1031. #endif
  1032.  
  1033.     x = pf[0];
  1034.     y = pf[1];
  1035.     z = pf[2];
  1036.     w = pf[3];
  1037. }
  1038.  
  1039. D3DXINLINE
  1040. D3DXQUATERNION::D3DXQUATERNION( CONST D3DXFLOAT16* pf )
  1041. {
  1042. #ifdef D3DX_DEBUG
  1043.     if(!pf)
  1044.         return;
  1045. #endif
  1046.  
  1047.     D3DXFloat16To32Array(&x, pf, 4);
  1048. }
  1049.  
  1050. D3DXINLINE
  1051. D3DXQUATERNION::D3DXQUATERNION( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
  1052. {
  1053.     x = fx;
  1054.     y = fy;
  1055.     z = fz;
  1056.     w = fw;
  1057. }
  1058.  
  1059.  
  1060. // casting
  1061. D3DXINLINE
  1062. D3DXQUATERNION::operator FLOAT* ()
  1063. {
  1064.     return (FLOAT *) &x;
  1065. }
  1066.  
  1067. D3DXINLINE
  1068. D3DXQUATERNION::operator CONST FLOAT* () const
  1069. {
  1070.     return (CONST FLOAT *) &x;
  1071. }
  1072.  
  1073.  
  1074. // assignment operators
  1075. D3DXINLINE D3DXQUATERNION&
  1076. D3DXQUATERNION::operator += ( CONST D3DXQUATERNION& q )
  1077. {
  1078.     x += q.x;
  1079.     y += q.y;
  1080.     z += q.z;
  1081.     w += q.w;
  1082.     return *this;
  1083. }
  1084.  
  1085. D3DXINLINE D3DXQUATERNION&
  1086. D3DXQUATERNION::operator -= ( CONST D3DXQUATERNION& q )
  1087. {
  1088.     x -= q.x;
  1089.     y -= q.y;
  1090.     z -= q.z;
  1091.     w -= q.w;
  1092.     return *this;
  1093. }
  1094.  
  1095. D3DXINLINE D3DXQUATERNION&
  1096. D3DXQUATERNION::operator *= ( CONST D3DXQUATERNION& q )
  1097. {
  1098.     D3DXQuaternionMultiply(this, this, &q);
  1099.     return *this;
  1100. }
  1101.  
  1102. D3DXINLINE D3DXQUATERNION&
  1103. D3DXQUATERNION::operator *= ( FLOAT f )
  1104. {
  1105.     x *= f;
  1106.     y *= f;
  1107.     z *= f;
  1108.     w *= f;
  1109.     return *this;
  1110. }
  1111.  
  1112. D3DXINLINE D3DXQUATERNION&
  1113. D3DXQUATERNION::operator /= ( FLOAT f )
  1114. {
  1115.     FLOAT fInv = 1.0f / f;
  1116.     x *= fInv;
  1117.     y *= fInv;
  1118.     z *= fInv;
  1119.     w *= fInv;
  1120.     return *this;
  1121. }
  1122.  
  1123.  
  1124. // unary operators
  1125. D3DXINLINE D3DXQUATERNION
  1126. D3DXQUATERNION::operator + () const
  1127. {
  1128.     return *this;
  1129. }
  1130.  
  1131. D3DXINLINE D3DXQUATERNION
  1132. D3DXQUATERNION::operator - () const
  1133. {
  1134.     return D3DXQUATERNION(-x, -y, -z, -w);
  1135. }
  1136.  
  1137.  
  1138. // binary operators
  1139. D3DXINLINE D3DXQUATERNION
  1140. D3DXQUATERNION::operator + ( CONST D3DXQUATERNION& q ) const
  1141. {
  1142.     return D3DXQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w);
  1143. }
  1144.  
  1145. D3DXINLINE D3DXQUATERNION
  1146. D3DXQUATERNION::operator - ( CONST D3DXQUATERNION& q ) const
  1147. {
  1148.     return D3DXQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w);
  1149. }
  1150.  
  1151. D3DXINLINE D3DXQUATERNION
  1152. D3DXQUATERNION::operator * ( CONST D3DXQUATERNION& q ) const
  1153. {
  1154.     D3DXQUATERNION qT;
  1155.     D3DXQuaternionMultiply(&qT, this, &q);
  1156.     return qT;
  1157. }
  1158.  
  1159. D3DXINLINE D3DXQUATERNION
  1160. D3DXQUATERNION::operator * ( FLOAT f ) const
  1161. {
  1162.     return D3DXQUATERNION(x * f, y * f, z * f, w * f);
  1163. }
  1164.  
  1165. D3DXINLINE D3DXQUATERNION
  1166. D3DXQUATERNION::operator / ( FLOAT f ) const
  1167. {
  1168.     FLOAT fInv = 1.0f / f;
  1169.     return D3DXQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv);
  1170. }
  1171.  
  1172.  
  1173. D3DXINLINE D3DXQUATERNION
  1174. operator * (FLOAT f, CONST D3DXQUATERNION& q )
  1175. {
  1176.     return D3DXQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w);
  1177. }
  1178.  
  1179.  
  1180. D3DXINLINE BOOL
  1181. D3DXQUATERNION::operator == ( CONST D3DXQUATERNION& q ) const
  1182. {
  1183.     return x == q.x && y == q.y && z == q.z && w == q.w;
  1184. }
  1185.  
  1186. D3DXINLINE BOOL
  1187. D3DXQUATERNION::operator != ( CONST D3DXQUATERNION& q ) const
  1188. {
  1189.     return x != q.x || y != q.y || z != q.z || w != q.w;
  1190. }
  1191.  
  1192.  
  1193.  
  1194. //--------------------------
  1195. // Plane
  1196. //--------------------------
  1197.  
  1198. D3DXINLINE
  1199. D3DXPLANE::D3DXPLANE( CONST FLOAT* pf )
  1200. {
  1201. #ifdef D3DX_DEBUG
  1202.     if(!pf)
  1203.         return;
  1204. #endif
  1205.  
  1206.     a = pf[0];
  1207.     b = pf[1];
  1208.     c = pf[2];
  1209.     d = pf[3];
  1210. }
  1211.  
  1212. D3DXINLINE
  1213. D3DXPLANE::D3DXPLANE( CONST D3DXFLOAT16* pf )
  1214. {
  1215. #ifdef D3DX_DEBUG
  1216.     if(!pf)
  1217.         return;
  1218. #endif
  1219.  
  1220.     D3DXFloat16To32Array(&a, pf, 4);
  1221. }
  1222.  
  1223. D3DXINLINE
  1224. D3DXPLANE::D3DXPLANE( FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd )
  1225. {
  1226.     a = fa;
  1227.     b = fb;
  1228.     c = fc;
  1229.     d = fd;
  1230. }
  1231.  
  1232.  
  1233. // casting
  1234. D3DXINLINE
  1235. D3DXPLANE::operator FLOAT* ()
  1236. {
  1237.     return (FLOAT *) &a;
  1238. }
  1239.  
  1240. D3DXINLINE
  1241. D3DXPLANE::operator CONST FLOAT* () const
  1242. {
  1243.     return (CONST FLOAT *) &a;
  1244. }
  1245.  
  1246.  
  1247. // unary operators
  1248. D3DXINLINE D3DXPLANE
  1249. D3DXPLANE::operator + () const
  1250. {
  1251.     return *this;
  1252. }
  1253.  
  1254. D3DXINLINE D3DXPLANE
  1255. D3DXPLANE::operator - () const
  1256. {
  1257.     return D3DXPLANE(-a, -b, -c, -d);
  1258. }
  1259.  
  1260.  
  1261. // binary operators
  1262. D3DXINLINE BOOL
  1263. D3DXPLANE::operator == ( CONST D3DXPLANE& p ) const
  1264. {
  1265.     return a == p.a && b == p.b && c == p.c && d == p.d;
  1266. }
  1267.  
  1268. D3DXINLINE BOOL
  1269. D3DXPLANE::operator != ( CONST D3DXPLANE& p ) const
  1270. {
  1271.     return a != p.a || b != p.b || c != p.c || d != p.d;
  1272. }
  1273.  
  1274.  
  1275.  
  1276.  
  1277. //--------------------------
  1278. // Color
  1279. //--------------------------
  1280.  
  1281. D3DXINLINE
  1282. D3DXCOLOR::D3DXCOLOR( DWORD dw )
  1283. {
  1284.     CONST FLOAT f = 1.0f / 255.0f;
  1285.     r = f * (FLOAT) (unsigned char) (dw >> 16);
  1286.     g = f * (FLOAT) (unsigned char) (dw >>  8);
  1287.     b = f * (FLOAT) (unsigned char) (dw >>  0);
  1288.     a = f * (FLOAT) (unsigned char) (dw >> 24);
  1289. }
  1290.  
  1291. D3DXINLINE
  1292. D3DXCOLOR::D3DXCOLOR( CONST FLOAT* pf )
  1293. {
  1294. #ifdef D3DX_DEBUG
  1295.     if(!pf)
  1296.         return;
  1297. #endif
  1298.  
  1299.     r = pf[0];
  1300.     g = pf[1];
  1301.     b = pf[2];
  1302.     a = pf[3];
  1303. }
  1304.  
  1305. D3DXINLINE
  1306. D3DXCOLOR::D3DXCOLOR( CONST D3DXFLOAT16* pf )
  1307. {
  1308. #ifdef D3DX_DEBUG
  1309.     if(!pf)
  1310.         return;
  1311. #endif
  1312.  
  1313.     D3DXFloat16To32Array(&r, pf, 4);
  1314. }
  1315.  
  1316. D3DXINLINE
  1317. D3DXCOLOR::D3DXCOLOR( CONST D3DCOLORVALUE& c )
  1318. {
  1319.     r = c.r;
  1320.     g = c.g;
  1321.     b = c.b;
  1322.     a = c.a;
  1323. }
  1324.  
  1325. D3DXINLINE
  1326. D3DXCOLOR::D3DXCOLOR( FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa )
  1327. {
  1328.     r = fr;
  1329.     g = fg;
  1330.     b = fb;
  1331.     a = fa;
  1332. }
  1333.  
  1334.  
  1335. // casting
  1336. D3DXINLINE
  1337. D3DXCOLOR::operator DWORD () const
  1338. {
  1339.     DWORD dwR = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD) (r * 255.0f + 0.5f);
  1340.     DWORD dwG = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD) (g * 255.0f + 0.5f);
  1341.     DWORD dwB = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD) (b * 255.0f + 0.5f);
  1342.     DWORD dwA = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD) (a * 255.0f + 0.5f);
  1343.  
  1344.     return (dwA << 24) | (dwR << 16) | (dwG << 8) | dwB;
  1345. }
  1346.  
  1347.  
  1348. D3DXINLINE
  1349. D3DXCOLOR::operator FLOAT * ()
  1350. {
  1351.     return (FLOAT *) &r;
  1352. }
  1353.  
  1354. D3DXINLINE
  1355. D3DXCOLOR::operator CONST FLOAT * () const
  1356. {
  1357.     return (CONST FLOAT *) &r;
  1358. }
  1359.  
  1360.  
  1361. D3DXINLINE
  1362. D3DXCOLOR::operator D3DCOLORVALUE * ()
  1363. {
  1364.     return (D3DCOLORVALUE *) &r;
  1365. }
  1366.  
  1367. D3DXINLINE
  1368. D3DXCOLOR::operator CONST D3DCOLORVALUE * () const
  1369. {
  1370.     return (CONST D3DCOLORVALUE *) &r;
  1371. }
  1372.  
  1373.  
  1374. D3DXINLINE
  1375. D3DXCOLOR::operator D3DCOLORVALUE& ()
  1376. {
  1377.     return *((D3DCOLORVALUE *) &r);
  1378. }
  1379.  
  1380. D3DXINLINE
  1381. D3DXCOLOR::operator CONST D3DCOLORVALUE& () const
  1382. {
  1383.     return *((CONST D3DCOLORVALUE *) &r);
  1384. }
  1385.  
  1386.  
  1387. // assignment operators
  1388. D3DXINLINE D3DXCOLOR&
  1389. D3DXCOLOR::operator += ( CONST D3DXCOLOR& c )
  1390. {
  1391.     r += c.r;
  1392.     g += c.g;
  1393.     b += c.b;
  1394.     a += c.a;
  1395.     return *this;
  1396. }
  1397.  
  1398. D3DXINLINE D3DXCOLOR&
  1399. D3DXCOLOR::operator -= ( CONST D3DXCOLOR& c )
  1400. {
  1401.     r -= c.r;
  1402.     g -= c.g;
  1403.     b -= c.b;
  1404.     a -= c.a;
  1405.     return *this;
  1406. }
  1407.  
  1408. D3DXINLINE D3DXCOLOR&
  1409. D3DXCOLOR::operator *= ( FLOAT f )
  1410. {
  1411.     r *= f;
  1412.     g *= f;
  1413.     b *= f;
  1414.     a *= f;
  1415.     return *this;
  1416. }
  1417.  
  1418. D3DXINLINE D3DXCOLOR&
  1419. D3DXCOLOR::operator /= ( FLOAT f )
  1420. {
  1421.     FLOAT fInv = 1.0f / f;
  1422.     r *= fInv;
  1423.     g *= fInv;
  1424.     b *= fInv;
  1425.     a *= fInv;
  1426.     return *this;
  1427. }
  1428.  
  1429.  
  1430. // unary operators
  1431. D3DXINLINE D3DXCOLOR
  1432. D3DXCOLOR::operator + () const
  1433. {
  1434.     return *this;
  1435. }
  1436.  
  1437. D3DXINLINE D3DXCOLOR
  1438. D3DXCOLOR::operator - () const
  1439. {
  1440.     return D3DXCOLOR(-r, -g, -b, -a);
  1441. }
  1442.  
  1443.  
  1444. // binary operators
  1445. D3DXINLINE D3DXCOLOR
  1446. D3DXCOLOR::operator + ( CONST D3DXCOLOR& c ) const
  1447. {
  1448.     return D3DXCOLOR(r + c.r, g + c.g, b + c.b, a + c.a);
  1449. }
  1450.  
  1451. D3DXINLINE D3DXCOLOR
  1452. D3DXCOLOR::operator - ( CONST D3DXCOLOR& c ) const
  1453. {
  1454.     return D3DXCOLOR(r - c.r, g - c.g, b - c.b, a - c.a);
  1455. }
  1456.  
  1457. D3DXINLINE D3DXCOLOR
  1458. D3DXCOLOR::operator * ( FLOAT f ) const
  1459. {
  1460.     return D3DXCOLOR(r * f, g * f, b * f, a * f);
  1461. }
  1462.  
  1463. D3DXINLINE D3DXCOLOR
  1464. D3DXCOLOR::operator / ( FLOAT f ) const
  1465. {
  1466.     FLOAT fInv = 1.0f / f;
  1467.     return D3DXCOLOR(r * fInv, g * fInv, b * fInv, a * fInv);
  1468. }
  1469.  
  1470.  
  1471. D3DXINLINE D3DXCOLOR
  1472. operator * (FLOAT f, CONST D3DXCOLOR& c )
  1473. {
  1474.     return D3DXCOLOR(f * c.r, f * c.g, f * c.b, f * c.a);
  1475. }
  1476.  
  1477.  
  1478. D3DXINLINE BOOL
  1479. D3DXCOLOR::operator == ( CONST D3DXCOLOR& c ) const
  1480. {
  1481.     return r == c.r && g == c.g && b == c.b && a == c.a;
  1482. }
  1483.  
  1484. D3DXINLINE BOOL
  1485. D3DXCOLOR::operator != ( CONST D3DXCOLOR& c ) const
  1486. {
  1487.     return r != c.r || g != c.g || b != c.b || a != c.a;
  1488. }
  1489.  
  1490.  
  1491. #endif //__cplusplus
  1492.  
  1493.  
  1494.  
  1495. //===========================================================================
  1496. //
  1497. // Inline functions
  1498. //
  1499. //===========================================================================
  1500.  
  1501.  
  1502. //--------------------------
  1503. // 2D Vector
  1504. //--------------------------
  1505.  
  1506. D3DXINLINE FLOAT D3DXVec2Length
  1507.     ( CONST D3DXVECTOR2 *pV )
  1508. {
  1509. #ifdef D3DX_DEBUG
  1510.     if(!pV)
  1511.         return 0.0f;
  1512. #endif
  1513.  
  1514. #ifdef __cplusplus
  1515.     return sqrtf(pV->x * pV->x + pV->y * pV->y);
  1516. #else
  1517.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y);
  1518. #endif
  1519. }
  1520.  
  1521. D3DXINLINE FLOAT D3DXVec2LengthSq
  1522.     ( CONST D3DXVECTOR2 *pV )
  1523. {
  1524. #ifdef D3DX_DEBUG
  1525.     if(!pV)
  1526.         return 0.0f;
  1527. #endif
  1528.  
  1529.     return pV->x * pV->x + pV->y * pV->y;
  1530. }
  1531.  
  1532. D3DXINLINE FLOAT D3DXVec2Dot
  1533.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1534. {
  1535. #ifdef D3DX_DEBUG
  1536.     if(!pV1 || !pV2)
  1537.         return 0.0f;
  1538. #endif
  1539.  
  1540.     return pV1->x * pV2->x + pV1->y * pV2->y;
  1541. }
  1542.  
  1543. D3DXINLINE FLOAT D3DXVec2CCW
  1544.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1545. {
  1546. #ifdef D3DX_DEBUG
  1547.     if(!pV1 || !pV2)
  1548.         return 0.0f;
  1549. #endif
  1550.  
  1551.     return pV1->x * pV2->y - pV1->y * pV2->x;
  1552. }
  1553.  
  1554. D3DXINLINE D3DXVECTOR2* D3DXVec2Add
  1555.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1556. {
  1557. #ifdef D3DX_DEBUG
  1558.     if(!pOut || !pV1 || !pV2)
  1559.         return NULL;
  1560. #endif
  1561.  
  1562.     pOut->x = pV1->x + pV2->x;
  1563.     pOut->y = pV1->y + pV2->y;
  1564.     return pOut;
  1565. }
  1566.  
  1567. D3DXINLINE D3DXVECTOR2* D3DXVec2Subtract
  1568.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1569. {
  1570. #ifdef D3DX_DEBUG
  1571.     if(!pOut || !pV1 || !pV2)
  1572.         return NULL;
  1573. #endif
  1574.  
  1575.     pOut->x = pV1->x - pV2->x;
  1576.     pOut->y = pV1->y - pV2->y;
  1577.     return pOut;
  1578. }
  1579.  
  1580. D3DXINLINE D3DXVECTOR2* D3DXVec2Minimize
  1581.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1582. {
  1583. #ifdef D3DX_DEBUG
  1584.     if(!pOut || !pV1 || !pV2)
  1585.         return NULL;
  1586. #endif
  1587.  
  1588.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1589.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1590.     return pOut;
  1591. }
  1592.  
  1593. D3DXINLINE D3DXVECTOR2* D3DXVec2Maximize
  1594.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1595. {
  1596. #ifdef D3DX_DEBUG
  1597.     if(!pOut || !pV1 || !pV2)
  1598.         return NULL;
  1599. #endif
  1600.  
  1601.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1602.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1603.     return pOut;
  1604. }
  1605.  
  1606. D3DXINLINE D3DXVECTOR2* D3DXVec2Scale
  1607.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s )
  1608. {
  1609. #ifdef D3DX_DEBUG
  1610.     if(!pOut || !pV)
  1611.         return NULL;
  1612. #endif
  1613.  
  1614.     pOut->x = pV->x * s;
  1615.     pOut->y = pV->y * s;
  1616.     return pOut;
  1617. }
  1618.  
  1619. D3DXINLINE D3DXVECTOR2* D3DXVec2Lerp
  1620.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2,
  1621.       FLOAT s )
  1622. {
  1623. #ifdef D3DX_DEBUG
  1624.     if(!pOut || !pV1 || !pV2)
  1625.         return NULL;
  1626. #endif
  1627.  
  1628.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1629.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1630.     return pOut;
  1631. }
  1632.  
  1633.  
  1634. //--------------------------
  1635. // 3D Vector
  1636. //--------------------------
  1637.  
  1638. D3DXINLINE FLOAT D3DXVec3Length
  1639.     ( CONST D3DXVECTOR3 *pV )
  1640. {
  1641. #ifdef D3DX_DEBUG
  1642.     if(!pV)
  1643.         return 0.0f;
  1644. #endif
  1645.  
  1646. #ifdef __cplusplus
  1647.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1648. #else
  1649.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1650. #endif
  1651. }
  1652.  
  1653. D3DXINLINE FLOAT D3DXVec3LengthSq
  1654.     ( CONST D3DXVECTOR3 *pV )
  1655. {
  1656. #ifdef D3DX_DEBUG
  1657.     if(!pV)
  1658.         return 0.0f;
  1659. #endif
  1660.  
  1661.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z;
  1662. }
  1663.  
  1664. D3DXINLINE FLOAT D3DXVec3Dot
  1665.     ( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1666. {
  1667. #ifdef D3DX_DEBUG
  1668.     if(!pV1 || !pV2)
  1669.         return 0.0f;
  1670. #endif
  1671.  
  1672.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
  1673. }
  1674.  
  1675. D3DXINLINE D3DXVECTOR3* D3DXVec3Cross
  1676.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1677. {
  1678.     D3DXVECTOR3 v;
  1679.  
  1680. #ifdef D3DX_DEBUG
  1681.     if(!pOut || !pV1 || !pV2)
  1682.         return NULL;
  1683. #endif
  1684.  
  1685.     v.x = pV1->y * pV2->z - pV1->z * pV2->y;
  1686.     v.y = pV1->z * pV2->x - pV1->x * pV2->z;
  1687.     v.z = pV1->x * pV2->y - pV1->y * pV2->x;
  1688.  
  1689.     *pOut = v;
  1690.     return pOut;
  1691. }
  1692.  
  1693. D3DXINLINE D3DXVECTOR3* D3DXVec3Add
  1694.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1695. {
  1696. #ifdef D3DX_DEBUG
  1697.     if(!pOut || !pV1 || !pV2)
  1698.         return NULL;
  1699. #endif
  1700.  
  1701.     pOut->x = pV1->x + pV2->x;
  1702.     pOut->y = pV1->y + pV2->y;
  1703.     pOut->z = pV1->z + pV2->z;
  1704.     return pOut;
  1705. }
  1706.  
  1707. D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract
  1708.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1709. {
  1710. #ifdef D3DX_DEBUG
  1711.     if(!pOut || !pV1 || !pV2)
  1712.         return NULL;
  1713. #endif
  1714.  
  1715.     pOut->x = pV1->x - pV2->x;
  1716.     pOut->y = pV1->y - pV2->y;
  1717.     pOut->z = pV1->z - pV2->z;
  1718.     return pOut;
  1719. }
  1720.  
  1721. D3DXINLINE D3DXVECTOR3* D3DXVec3Minimize
  1722.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1723. {
  1724. #ifdef D3DX_DEBUG
  1725.     if(!pOut || !pV1 || !pV2)
  1726.         return NULL;
  1727. #endif
  1728.  
  1729.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1730.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1731.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1732.     return pOut;
  1733. }
  1734.  
  1735. D3DXINLINE D3DXVECTOR3* D3DXVec3Maximize
  1736.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1737. {
  1738. #ifdef D3DX_DEBUG
  1739.     if(!pOut || !pV1 || !pV2)
  1740.         return NULL;
  1741. #endif
  1742.  
  1743.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1744.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1745.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1746.     return pOut;
  1747. }
  1748.  
  1749. D3DXINLINE D3DXVECTOR3* D3DXVec3Scale
  1750.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s)
  1751. {
  1752. #ifdef D3DX_DEBUG
  1753.     if(!pOut || !pV)
  1754.         return NULL;
  1755. #endif
  1756.  
  1757.     pOut->x = pV->x * s;
  1758.     pOut->y = pV->y * s;
  1759.     pOut->z = pV->z * s;
  1760.     return pOut;
  1761. }
  1762.  
  1763. D3DXINLINE D3DXVECTOR3* D3DXVec3Lerp
  1764.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
  1765.       FLOAT s )
  1766. {
  1767. #ifdef D3DX_DEBUG
  1768.     if(!pOut || !pV1 || !pV2)
  1769.         return NULL;
  1770. #endif
  1771.  
  1772.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1773.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1774.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1775.     return pOut;
  1776. }
  1777.  
  1778.  
  1779. //--------------------------
  1780. // 4D Vector
  1781. //--------------------------
  1782.  
  1783. D3DXINLINE FLOAT D3DXVec4Length
  1784.     ( CONST D3DXVECTOR4 *pV )
  1785. {
  1786. #ifdef D3DX_DEBUG
  1787.     if(!pV)
  1788.         return 0.0f;
  1789. #endif
  1790.  
  1791. #ifdef __cplusplus
  1792.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1793. #else
  1794.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1795. #endif
  1796. }
  1797.  
  1798. D3DXINLINE FLOAT D3DXVec4LengthSq
  1799.     ( CONST D3DXVECTOR4 *pV )
  1800. {
  1801. #ifdef D3DX_DEBUG
  1802.     if(!pV)
  1803.         return 0.0f;
  1804. #endif
  1805.  
  1806.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w;
  1807. }
  1808.  
  1809. D3DXINLINE FLOAT D3DXVec4Dot
  1810.     ( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 )
  1811. {
  1812. #ifdef D3DX_DEBUG
  1813.     if(!pV1 || !pV2)
  1814.         return 0.0f;
  1815. #endif
  1816.  
  1817.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z + pV1->w * pV2->w;
  1818. }
  1819.  
  1820. D3DXINLINE D3DXVECTOR4* D3DXVec4Add
  1821.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1822. {
  1823. #ifdef D3DX_DEBUG
  1824.     if(!pOut || !pV1 || !pV2)
  1825.         return NULL;
  1826. #endif
  1827.  
  1828.     pOut->x = pV1->x + pV2->x;
  1829.     pOut->y = pV1->y + pV2->y;
  1830.     pOut->z = pV1->z + pV2->z;
  1831.     pOut->w = pV1->w + pV2->w;
  1832.     return pOut;
  1833. }
  1834.  
  1835. D3DXINLINE D3DXVECTOR4* D3DXVec4Subtract
  1836.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1837. {
  1838. #ifdef D3DX_DEBUG
  1839.     if(!pOut || !pV1 || !pV2)
  1840.         return NULL;
  1841. #endif
  1842.  
  1843.     pOut->x = pV1->x - pV2->x;
  1844.     pOut->y = pV1->y - pV2->y;
  1845.     pOut->z = pV1->z - pV2->z;
  1846.     pOut->w = pV1->w - pV2->w;
  1847.     return pOut;
  1848. }
  1849.  
  1850. D3DXINLINE D3DXVECTOR4* D3DXVec4Minimize
  1851.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1852. {
  1853. #ifdef D3DX_DEBUG
  1854.     if(!pOut || !pV1 || !pV2)
  1855.         return NULL;
  1856. #endif
  1857.  
  1858.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1859.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1860.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1861.     pOut->w = pV1->w < pV2->w ? pV1->w : pV2->w;
  1862.     return pOut;
  1863. }
  1864.  
  1865. D3DXINLINE D3DXVECTOR4* D3DXVec4Maximize
  1866.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1867. {
  1868. #ifdef D3DX_DEBUG
  1869.     if(!pOut || !pV1 || !pV2)
  1870.         return NULL;
  1871. #endif
  1872.  
  1873.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1874.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1875.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1876.     pOut->w = pV1->w > pV2->w ? pV1->w : pV2->w;
  1877.     return pOut;
  1878. }
  1879.  
  1880. D3DXINLINE D3DXVECTOR4* D3DXVec4Scale
  1881.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s)
  1882. {
  1883. #ifdef D3DX_DEBUG
  1884.     if(!pOut || !pV)
  1885.         return NULL;
  1886. #endif
  1887.  
  1888.     pOut->x = pV->x * s;
  1889.     pOut->y = pV->y * s;
  1890.     pOut->z = pV->z * s;
  1891.     pOut->w = pV->w * s;
  1892.     return pOut;
  1893. }
  1894.  
  1895. D3DXINLINE D3DXVECTOR4* D3DXVec4Lerp
  1896.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
  1897.       FLOAT s )
  1898. {
  1899. #ifdef D3DX_DEBUG
  1900.     if(!pOut || !pV1 || !pV2)
  1901.         return NULL;
  1902. #endif
  1903.  
  1904.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1905.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1906.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1907.     pOut->w = pV1->w + s * (pV2->w - pV1->w);
  1908.     return pOut;
  1909. }
  1910.  
  1911.  
  1912. //--------------------------
  1913. // 4D Matrix
  1914. //--------------------------
  1915.  
  1916. D3DXINLINE D3DXMATRIX* D3DXMatrixIdentity
  1917.     ( D3DXMATRIX *pOut )
  1918. {
  1919. #ifdef D3DX_DEBUG
  1920.     if(!pOut)
  1921.         return NULL;
  1922. #endif
  1923.  
  1924.     pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] =
  1925.     pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] =
  1926.     pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] =
  1927.     pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f;
  1928.  
  1929.     pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f;
  1930.     return pOut;
  1931. }
  1932.  
  1933.  
  1934. D3DXINLINE BOOL D3DXMatrixIsIdentity
  1935.     ( CONST D3DXMATRIX *pM )
  1936. {
  1937. #ifdef D3DX_DEBUG
  1938.     if(!pM)
  1939.         return FALSE;
  1940. #endif
  1941.  
  1942.     return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f &&
  1943.            pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f &&
  1944.            pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f &&
  1945.            pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f;
  1946. }
  1947.  
  1948.  
  1949. //--------------------------
  1950. // Quaternion
  1951. //--------------------------
  1952.  
  1953. D3DXINLINE FLOAT D3DXQuaternionLength
  1954.     ( CONST D3DXQUATERNION *pQ )
  1955. {
  1956. #ifdef D3DX_DEBUG
  1957.     if(!pQ)
  1958.         return 0.0f;
  1959. #endif
  1960.  
  1961. #ifdef __cplusplus
  1962.     return sqrtf(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  1963. #else
  1964.     return (FLOAT) sqrt(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  1965. #endif
  1966. }
  1967.  
  1968. D3DXINLINE FLOAT D3DXQuaternionLengthSq
  1969.     ( CONST D3DXQUATERNION *pQ )
  1970. {
  1971. #ifdef D3DX_DEBUG
  1972.     if(!pQ)
  1973.         return 0.0f;
  1974. #endif
  1975.  
  1976.     return pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w;
  1977. }
  1978.  
  1979. D3DXINLINE FLOAT D3DXQuaternionDot
  1980.     ( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 )
  1981. {
  1982. #ifdef D3DX_DEBUG
  1983.     if(!pQ1 || !pQ2)
  1984.         return 0.0f;
  1985. #endif
  1986.  
  1987.     return pQ1->x * pQ2->x + pQ1->y * pQ2->y + pQ1->z * pQ2->z + pQ1->w * pQ2->w;
  1988. }
  1989.  
  1990.  
  1991. D3DXINLINE D3DXQUATERNION* D3DXQuaternionIdentity
  1992.     ( D3DXQUATERNION *pOut )
  1993. {
  1994. #ifdef D3DX_DEBUG
  1995.     if(!pOut)
  1996.         return NULL;
  1997. #endif
  1998.  
  1999.     pOut->x = pOut->y = pOut->z = 0.0f;
  2000.     pOut->w = 1.0f;
  2001.     return pOut;
  2002. }
  2003.  
  2004. D3DXINLINE BOOL D3DXQuaternionIsIdentity
  2005.     ( CONST D3DXQUATERNION *pQ )
  2006. {
  2007. #ifdef D3DX_DEBUG
  2008.     if(!pQ)
  2009.         return FALSE;
  2010. #endif
  2011.  
  2012.     return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f;
  2013. }
  2014.  
  2015.  
  2016. D3DXINLINE D3DXQUATERNION* D3DXQuaternionConjugate
  2017.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ )
  2018. {
  2019. #ifdef D3DX_DEBUG
  2020.     if(!pOut || !pQ)
  2021.         return NULL;
  2022. #endif
  2023.  
  2024.     pOut->x = -pQ->x;
  2025.     pOut->y = -pQ->y;
  2026.     pOut->z = -pQ->z;
  2027.     pOut->w =  pQ->w;
  2028.     return pOut;
  2029. }
  2030.  
  2031.  
  2032. //--------------------------
  2033. // Plane
  2034. //--------------------------
  2035.  
  2036. D3DXINLINE FLOAT D3DXPlaneDot
  2037.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV)
  2038. {
  2039. #ifdef D3DX_DEBUG
  2040.     if(!pP || !pV)
  2041.         return 0.0f;
  2042. #endif
  2043.  
  2044.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d * pV->w;
  2045. }
  2046.  
  2047. D3DXINLINE FLOAT D3DXPlaneDotCoord
  2048.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
  2049. {
  2050. #ifdef D3DX_DEBUG
  2051.     if(!pP || !pV)
  2052.         return 0.0f;
  2053. #endif
  2054.  
  2055.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d;
  2056. }
  2057.  
  2058. D3DXINLINE FLOAT D3DXPlaneDotNormal
  2059.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
  2060. {
  2061. #ifdef D3DX_DEBUG
  2062.     if(!pP || !pV)
  2063.         return 0.0f;
  2064. #endif
  2065.  
  2066.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z;
  2067. }
  2068.  
  2069.  
  2070. //--------------------------
  2071. // Color
  2072. //--------------------------
  2073.  
  2074. D3DXINLINE D3DXCOLOR* D3DXColorNegative
  2075.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC)
  2076. {
  2077. #ifdef D3DX_DEBUG
  2078.     if(!pOut || !pC)
  2079.         return NULL;
  2080. #endif
  2081.  
  2082.     pOut->r = 1.0f - pC->r;
  2083.     pOut->g = 1.0f - pC->g;
  2084.     pOut->b = 1.0f - pC->b;
  2085.     pOut->a = pC->a;
  2086.     return pOut;
  2087. }
  2088.  
  2089. D3DXINLINE D3DXCOLOR* D3DXColorAdd
  2090.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2091. {
  2092. #ifdef D3DX_DEBUG
  2093.     if(!pOut || !pC1 || !pC2)
  2094.         return NULL;
  2095. #endif
  2096.  
  2097.     pOut->r = pC1->r + pC2->r;
  2098.     pOut->g = pC1->g + pC2->g;
  2099.     pOut->b = pC1->b + pC2->b;
  2100.     pOut->a = pC1->a + pC2->a;
  2101.     return pOut;
  2102. }
  2103.  
  2104. D3DXINLINE D3DXCOLOR* D3DXColorSubtract
  2105.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2106. {
  2107. #ifdef D3DX_DEBUG
  2108.     if(!pOut || !pC1 || !pC2)
  2109.         return NULL;
  2110. #endif
  2111.  
  2112.     pOut->r = pC1->r - pC2->r;
  2113.     pOut->g = pC1->g - pC2->g;
  2114.     pOut->b = pC1->b - pC2->b;
  2115.     pOut->a = pC1->a - pC2->a;
  2116.     return pOut;
  2117. }
  2118.  
  2119. D3DXINLINE D3DXCOLOR* D3DXColorScale
  2120.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s)
  2121. {
  2122. #ifdef D3DX_DEBUG
  2123.     if(!pOut || !pC)
  2124.         return NULL;
  2125. #endif
  2126.  
  2127.     pOut->r = pC->r * s;
  2128.     pOut->g = pC->g * s;
  2129.     pOut->b = pC->b * s;
  2130.     pOut->a = pC->a * s;
  2131.     return pOut;
  2132. }
  2133.  
  2134. D3DXINLINE D3DXCOLOR* D3DXColorModulate
  2135.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2136. {
  2137. #ifdef D3DX_DEBUG
  2138.     if(!pOut || !pC1 || !pC2)
  2139.         return NULL;
  2140. #endif
  2141.  
  2142.     pOut->r = pC1->r * pC2->r;
  2143.     pOut->g = pC1->g * pC2->g;
  2144.     pOut->b = pC1->b * pC2->b;
  2145.     pOut->a = pC1->a * pC2->a;
  2146.     return pOut;
  2147. }
  2148.  
  2149. D3DXINLINE D3DXCOLOR* D3DXColorLerp
  2150.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s)
  2151. {
  2152. #ifdef D3DX_DEBUG
  2153.     if(!pOut || !pC1 || !pC2)
  2154.         return NULL;
  2155. #endif
  2156.  
  2157.     pOut->r = pC1->r + s * (pC2->r - pC1->r);
  2158.     pOut->g = pC1->g + s * (pC2->g - pC1->g);
  2159.     pOut->b = pC1->b + s * (pC2->b - pC1->b);
  2160.     pOut->a = pC1->a + s * (pC2->a - pC1->a);
  2161.     return pOut;
  2162. }
  2163.  
  2164.  
  2165. #endif // __D3DX9MATH_INL__
  2166.